const express = require('express');
const { body, param, query, validationResult } = require('express-validator');
const Role = require('../models/Role');
const Menu = require('../models/Menu');

const router = express.Router();

// 验证错误处理中间件
const handleValidationErrors = (req, res, next) => {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({
      success: false,
      message: '请求参数验证失败',
      errors: errors.array()
    });
  }
  next();
};

// 获取角色列表
router.get('/', [
  query('page').optional().isInt({ min: 1 }).withMessage('页码必须是正整数'),
  query('limit').optional().isInt({ min: 1, max: 100 }).withMessage('每页数量必须在1-100之间'),
  query('search').optional().isString().withMessage('搜索关键词必须是字符串'),
  handleValidationErrors
], async (req, res) => {
  try {
    const { page = 1, limit = 10, search = '' } = req.query;
    const result = await Role.findAll(page, limit, search);
    
    res.json({
      success: true,
      message: '获取角色列表成功',
      data: result
    });
  } catch (error) {
    console.error('获取角色列表错误:', error);
    res.status(500).json({
      success: false,
      message: error.message || '获取角色列表失败'
    });
  }
});

// 获取单个角色
router.get('/:id', [
  param('id').isInt({ min: 1 }).withMessage('角色ID必须是正整数'),
  handleValidationErrors
], async (req, res) => {
  try {
    const { id } = req.params;
    const role = await Role.findById(id);
    
    if (!role) {
      return res.status(404).json({
        success: false,
        message: '角色不存在'
      });
    }
    
    // 获取角色权限
    const permissions = await Role.getPermissions(id);
    // 获取角色菜单
    const menus = await Role.getMenus(id);
    
    res.json({
      success: true,
      message: '获取角色信息成功',
      data: {
        ...role,
        permissions,
        menus
      }
    });
  } catch (error) {
    console.error('获取角色错误:', error);
    res.status(500).json({
      success: false,
      message: error.message || '获取角色失败'
    });
  }
});

// 创建角色
router.post('/', [
  body('name').isLength({ min: 2, max: 50 }).withMessage('角色名称长度必须在2-50个字符之间'),
  body('code').isLength({ min: 2, max: 50 }).withMessage('角色代码长度必须在2-50个字符之间'),
  body('description').optional().isLength({ max: 200 }).withMessage('描述长度不能超过200个字符'),
  body('permissions').optional().isArray().withMessage('权限必须是数组'),
  handleValidationErrors
], async (req, res) => {
  try {
    const { name, code, description, permissions } = req.body;
    
    const newRole = await Role.create({ name, code, description });
    
    // 设置角色权限
    if (permissions && permissions.length > 0) {
      await Role.setPermissions(newRole.id, permissions);
    }
    
    res.status(201).json({
      success: true,
      message: '创建角色成功',
      data: newRole
    });
  } catch (error) {
    console.error('创建角色错误:', error);
    res.status(500).json({
      success: false,
      message: error.message || '创建角色失败'
    });
  }
});

// 更新角色
router.put('/:id', [
  param('id').isInt({ min: 1 }).withMessage('角色ID必须是正整数'),
  body('name').optional().isLength({ min: 2, max: 50 }).withMessage('角色名称长度必须在2-50个字符之间'),
  body('code').optional().isLength({ min: 2, max: 50 }).withMessage('角色代码长度必须在2-50个字符之间'),
  body('description').optional().isLength({ max: 200 }).withMessage('描述长度不能超过200个字符'),
  handleValidationErrors
], async (req, res) => {
  try {
    const { id } = req.params;
    const roleData = req.body;
    
    const updatedRole = await Role.update(id, roleData);
    
    res.json({
      success: true,
      message: '更新角色成功',
      data: updatedRole
    });
  } catch (error) {
    console.error('更新角色错误:', error);
    res.status(500).json({
      success: false,
      message: error.message || '更新角色失败'
    });
  }
});

// 设置角色权限
router.put('/:id/permissions', [
  param('id').isInt({ min: 1 }).withMessage('角色ID必须是正整数'),
  body('permissions').isArray().withMessage('权限必须是数组'),
  handleValidationErrors
], async (req, res) => {
  try {
    const { id } = req.params;
    const { permissions } = req.body;
    
    await Role.setPermissions(id, permissions);
    
    res.json({
      success: true,
      message: '设置角色权限成功'
    });
  } catch (error) {
    console.error('设置角色权限错误:', error);
    res.status(500).json({
      success: false,
      message: error.message || '设置角色权限失败'
    });
  }
});

// 删除角色
router.delete('/:id', [
  param('id').isInt({ min: 1 }).withMessage('角色ID必须是正整数'),
  handleValidationErrors
], async (req, res) => {
  try {
    const { id } = req.params;
    
    await Role.delete(id);
    
    res.json({
      success: true,
      message: '删除角色成功'
    });
  } catch (error) {
    console.error('删除角色错误:', error);
    res.status(500).json({
      success: false,
      message: error.message || '删除角色失败'
    });
  }
});

// 批量删除角色
router.delete('/', [
  body('ids').isArray({ min: 1 }).withMessage('必须提供要删除的角色ID数组'),
  body('ids.*').isInt({ min: 1 }).withMessage('角色ID必须是正整数'),
  handleValidationErrors
], async (req, res) => {
  try {
    const { ids } = req.body;
    
    const deletedCount = await Role.deleteMultiple(ids);
    
    res.json({
      success: true,
      message: `成功删除 ${deletedCount} 个角色`,
      data: { deletedCount }
    });
  } catch (error) {
    console.error('批量删除角色错误:', error);
    res.status(500).json({
      success: false,
      message: error.message || '批量删除角色失败'
    });
  }
});

// 获取角色统计信息
router.get('/stats/overview', async (req, res) => {
  try {
    const stats = await Role.getStats();
    
    res.json({
      success: true,
      message: '获取角色统计成功',
      data: stats
    });
  } catch (error) {
    console.error('获取角色统计错误:', error);
    res.status(500).json({
      success: false,
      message: error.message || '获取角色统计失败'
    });
  }
});

// 获取所有角色（用于下拉选择）
router.get('/options/all', async (req, res) => {
  try {
    const roles = await Role.getAllRoles();
    
    res.json({
      success: true,
      message: '获取角色选项成功',
      data: roles
    });
  } catch (error) {
    console.error('获取角色选项错误:', error);
    res.status(500).json({
      success: false,
      message: error.message || '获取角色选项失败'
    });
  }
});

// 获取可用权限列表
router.get('/permissions/available', async (req, res) => {
  try {
    // 定义系统可用权限
    const availablePermissions = [
      { code: 'user:read', name: '用户查看', description: '查看用户信息' },
      { code: 'user:write', name: '用户管理', description: '创建、编辑、删除用户' },
      { code: 'role:read', name: '角色查看', description: '查看角色信息' },
      { code: 'role:write', name: '角色管理', description: '创建、编辑、删除角色' },
      { code: 'department:read', name: '部门查看', description: '查看部门信息' },
      { code: 'department:write', name: '部门管理', description: '创建、编辑、删除部门' },
      { code: 'dashboard:read', name: '仪表板查看', description: '查看仪表板数据' },
      { code: 'settings:read', name: '设置查看', description: '查看系统设置' },
      { code: 'settings:write', name: '设置管理', description: '修改系统设置' }
    ];
    
    res.json({
      success: true,
      message: '获取可用权限成功',
      data: availablePermissions
    });
  } catch (error) {
    console.error('获取可用权限错误:', error);
    res.status(500).json({
      success: false,
      message: error.message || '获取可用权限失败'
    });
  }
});

// 获取角色已分配菜单ID
router.get('/:id/menus', async (req, res) => {
  try {
    const menuIds = await Role.getMenus(req.params.id);
    res.json({ success: true, data: menuIds });
  } catch (error) {
    res.status(500).json({ success: false, message: error.message });
  }
});

// 分配菜单权限
router.put('/:id/menus', async (req, res) => {
  try {
    const { menuIds } = req.body;
    await Role.setMenus(req.params.id, menuIds);
    res.json({ success: true, message: '分配菜单权限成功' });
  } catch (error) {
    res.status(500).json({ success: false, message: error.message });
  }
});

module.exports = router; 